{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9d1277ca-e639-4494-adc0-5f7bf30924a7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T06:47:14.328901Z",
     "iopub.status.busy": "2022-05-23T06:47:14.328593Z",
     "iopub.status.idle": "2022-05-23T06:47:14.331989Z",
     "shell.execute_reply": "2022-05-23T06:47:14.331435Z",
     "shell.execute_reply.started": "2022-05-23T06:47:14.328876Z"
    },
    "tags": []
   },
   "source": [
    "# MovieLens-1M数据处理\n",
    "在这个notebook中，我们会演示使用如何在AlphaIDE中使用MetaSpore，进行数据准备、Spark环境初始化、数据读取、数据分析等基础的操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4efaa9a2-d8d0-4b7b-9283-83f28ffd834d",
   "metadata": {},
   "source": [
    "### 1. 数据准备\n",
    "从MovieLens网站上下载数据，并上传到S3存储。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fc080836-a334-4e9e-b146-a347344878a4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:08.140621Z",
     "iopub.status.busy": "2022-05-23T12:13:08.140437Z",
     "iopub.status.idle": "2022-05-23T12:13:13.160172Z",
     "shell.execute_reply": "2022-05-23T12:13:13.159570Z",
     "shell.execute_reply.started": "2022-05-23T12:13:08.140559Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2022-05-23 20:13:08--  https://files.grouplens.org/datasets/movielens/ml-1m.zip\n",
      "Resolving files.grouplens.org (files.grouplens.org)... 128.101.65.152\n",
      "Connecting to files.grouplens.org (files.grouplens.org)|128.101.65.152|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 5917549 (5.6M) [application/zip]\n",
      "Saving to: ‘ml-1m.zip’\n",
      "\n",
      "ml-1m.zip           100%[===================>]   5.64M  3.12MB/s    in 1.8s    \n",
      "\n",
      "2022-05-23 20:13:13 (3.12 MB/s) - ‘ml-1m.zip’ saved [5917549/5917549]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!wget https://files.grouplens.org/datasets/movielens/ml-1m.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f16d85e0-8fc0-4701-8a15-7d3c9d90b48a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:13.161877Z",
     "iopub.status.busy": "2022-05-23T12:13:13.161443Z",
     "iopub.status.idle": "2022-05-23T12:13:13.739637Z",
     "shell.execute_reply": "2022-05-23T12:13:13.739088Z",
     "shell.execute_reply.started": "2022-05-23T12:13:13.161853Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Archive:  ml-1m.zip\n",
      "   creating: ml-1m/\n",
      "  inflating: ml-1m/movies.dat        \n",
      "  inflating: ml-1m/ratings.dat       \n",
      "  inflating: ml-1m/README            \n",
      "  inflating: ml-1m/users.dat         \n"
     ]
    }
   ],
   "source": [
    "!unzip ml-1m.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "603ddc5b-1c47-4af7-aec5-e75f11bcc273",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:13.740743Z",
     "iopub.status.busy": "2022-05-23T12:13:13.740550Z",
     "iopub.status.idle": "2022-05-23T12:13:15.102047Z",
     "shell.execute_reply": "2022-05-23T12:13:15.101441Z",
     "shell.execute_reply.started": "2022-05-23T12:13:13.740702Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "upload: ml-1m/README to s3://alphaide-demo/movielens/ml-1m/README\n",
      "upload: ml-1m/users.dat to s3://alphaide-demo/movielens/ml-1m/users.dat\n",
      "upload: ml-1m/movies.dat to s3://alphaide-demo/movielens/ml-1m/movies.dat\n",
      "upload: ml-1m/ratings.dat to s3://alphaide-demo/movielens/ml-1m/ratings.dat\n"
     ]
    }
   ],
   "source": [
    "!aws s3 cp --recursive ml-1m  s3://alphaide-demo/movielens/ml-1m/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a24dc465-23cb-4a4f-a3fe-99fcc00164d4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:15.103250Z",
     "iopub.status.busy": "2022-05-23T12:13:15.103023Z",
     "iopub.status.idle": "2022-05-23T12:13:15.874191Z",
     "shell.execute_reply": "2022-05-23T12:13:15.873536Z",
     "shell.execute_reply.started": "2022-05-23T12:13:15.103228Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           PRE rank/\n",
      "                           PRE schema/\n",
      "2022-05-23 20:13:14       5577 README\n",
      "2022-05-23 20:13:14     171308 movies.dat\n",
      "2022-05-23 20:13:14   24594131 ratings.dat\n",
      "2022-05-23 20:13:14     134368 users.dat\n"
     ]
    }
   ],
   "source": [
    "!aws s3 ls s3://alphaide-demo/movielens/ml-1m/"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2766c4b6-9a21-41bd-be8c-e9e36840fbe6",
   "metadata": {},
   "source": [
    "### 2. Spark环境初始化与数据读取\n",
    "初始化Spark环境，并读取Movies、Users、Ratings等数据表，测试我们读取过程是否可以顺利完成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3b03ad29-2726-4420-b853-78f03eb8cae0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:15.875649Z",
     "iopub.status.busy": "2022-05-23T12:13:15.875317Z",
     "iopub.status.idle": "2022-05-23T12:13:16.459366Z",
     "shell.execute_reply": "2022-05-23T12:13:16.458882Z",
     "shell.execute_reply.started": "2022-05-23T12:13:15.875626Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import metaspore as ms\n",
    "import yaml\n",
    "import argparse\n",
    "from pyspark.sql import SparkSession\n",
    "from pyspark.sql import functions as F\n",
    "from pyspark.sql.types import StructType, StructField, IntegerType, FloatType, LongType, StringType\n",
    "from functools import reduce\n",
    "\n",
    "def load_config(path):\n",
    "    params = dict()\n",
    "    with open(path, 'r') as stream:\n",
    "        params = yaml.load(stream, Loader=yaml.FullLoader)\n",
    "        print('Debug -- load config: ', params)\n",
    "    return params\n",
    "\n",
    "def init_spark():\n",
    "    \n",
    "    spark_confs={\n",
    "        \"spark.network.timeout\":\"500\",\n",
    "        \"spark.ui.showConsoleProgress\": \"true\",\n",
    "        \"spark.kubernetes.executor.deleteOnTermination\":\"true\",\n",
    "    }\n",
    "    spark_session = ms.spark.get_session(local=local,\n",
    "                                         app_name=app_name,\n",
    "                                         batch_size=batch_size,\n",
    "                                         worker_count=worker_count,\n",
    "                                         server_count=server_count,\n",
    "                                         worker_memory=worker_memory,\n",
    "                                         server_memory=server_memory,\n",
    "                                         coordinator_memory=coordinator_memory,\n",
    "                                         spark_confs=spark_confs)\n",
    "    sc = spark_session.sparkContext\n",
    "    print('Debug -- spark init')\n",
    "    print('Debug -- version:', sc.version)   \n",
    "    print('Debug -- applicaitonId:', sc.applicationId)\n",
    "    print('Debug -- uiWebUrl:', sc.uiWebUrl)\n",
    "    return spark_session\n",
    "\n",
    "def stop_spark(spark):\n",
    "    print('Debug -- spark stop')\n",
    "    spark.sparkContext.stop()\n",
    "\n",
    "def read_dataset(**kwargs):\n",
    "    ### read movies\n",
    "    movies_schema = StructType([\n",
    "            StructField(\"movie_id\", LongType(), True),\n",
    "            StructField(\"title\", StringType(), True),\n",
    "            StructField(\"genre\", StringType(), True)\n",
    "    ])\n",
    "\n",
    "    movies = spark.read.csv(movies_path, sep='::',inferSchema=False, header=False, schema=movies_schema)\n",
    "    print('Debug -- movies sample:')\n",
    "    movies.show(10)\n",
    "\n",
    "    ### read ratings\n",
    "    ratings_schema = StructType([\n",
    "            StructField(\"user_id\", LongType(), True),\n",
    "            StructField(\"movie_id\", LongType(), True),\n",
    "            StructField(\"rating\", FloatType(), True),\n",
    "            StructField(\"timestamp\", LongType(), True)\n",
    "    ])\n",
    "\n",
    "    ratings = spark.read.csv(ratings_path, sep='::', inferSchema=False, header=False, schema=ratings_schema)\n",
    "    print('Debug -- ratings sample:')\n",
    "    ratings.show(10)\n",
    "\n",
    "    ### read users\n",
    "    users_schema = StructType([\n",
    "            StructField(\"user_id\", LongType(), True),\n",
    "            StructField(\"gender\", StringType(), True),\n",
    "            StructField(\"age\", IntegerType(), True),\n",
    "            StructField(\"occupation\", StringType(), True),\n",
    "            StructField(\"zip\", StringType(), True)\n",
    "    ])\n",
    "\n",
    "    users = spark.read.csv(users_path, sep='::', inferSchema=False, header=False, schema=users_schema)\n",
    "    print('Debug -- users sample:')\n",
    "    users.show(10)\n",
    "\n",
    "    return users, movies, ratings\n",
    "\n",
    "def merge_dataset(users, movies, ratings):\n",
    "    # merge movies, users, ratings\n",
    "    dataset = ratings.join(users, on=ratings.user_id==users.user_id, how='leftouter').drop(users.user_id)\n",
    "    dataset = dataset.join(movies, on=dataset.movie_id==movies.movie_id,how='leftouter').drop(movies.movie_id)\n",
    "    dataset = dataset.select('user_id', \\\n",
    "                            'gender', \\\n",
    "                            'age', \\\n",
    "                            'occupation', \\\n",
    "                            'zip', \\\n",
    "                            'movie_id', \\\n",
    "                            'title', \\\n",
    "                            'genre', \\\n",
    "                            'rating', \\\n",
    "                            'timestamp'\n",
    "                            )\n",
    "    print('Debug -- dataset sample:')\n",
    "    dataset.show(10)\n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1c41c048-dfb8-44ef-b695-6b9e67f10800",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:16.460402Z",
     "iopub.status.busy": "2022-05-23T12:13:16.460193Z",
     "iopub.status.idle": "2022-05-23T12:13:21.050169Z",
     "shell.execute_reply": "2022-05-23T12:13:21.049651Z",
     "shell.execute_reply.started": "2022-05-23T12:13:16.460383Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Debug -- Movielens Feature Generation Demo\n",
      "Debug -- load config:  {'app_name': 'MovieLens-1M Data', 'local': True, 'worker_count': 2, 'server_count': 2, 'batch_size': 1024, 'worker_memory': '7G', 'server_memory': '7G', 'coordinator_memory': '7G', 'movies_path': 's3://alphaide-demo/movielens/ml-1m/movies.dat', 'ratings_path': 's3://alphaide-demo/movielens/ml-1m/ratings.dat', 'users_path': 's3://alphaide-demo/movielens/ml-1m/users.dat'}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: An illegal reflective access operation has occurred\n",
      "WARNING: Illegal reflective access by org.apache.spark.unsafe.Platform (file:/usr/local/lib/python3.8/dist-packages/pyspark/jars/spark-unsafe_2.12-3.1.2.jar) to constructor java.nio.DirectByteBuffer(long,int)\n",
      "WARNING: Please consider reporting this to the maintainers of org.apache.spark.unsafe.Platform\n",
      "WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations\n",
      "WARNING: All illegal access operations will be denied in a future release\n",
      "22/05/23 20:13:17 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n",
      "Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties\n",
      "Setting default log level to \"WARN\".\n",
      "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Debug -- spark init\n",
      "Debug -- version: 3.1.2\n",
      "Debug -- applicaitonId: local-1653307998805\n",
      "Debug -- uiWebUrl: http://movielens-102-0:4040\n"
     ]
    }
   ],
   "source": [
    "print('Debug -- Movielens Feature Generation Demo')\n",
    "params = load_config('./1-data_exploration.yaml')\n",
    "locals().update(params)\n",
    "spark = init_spark()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d0c403c7-7c7c-40c7-b489-22f219346668",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:21.052427Z",
     "iopub.status.busy": "2022-05-23T12:13:21.052095Z",
     "iopub.status.idle": "2022-05-23T12:13:25.037408Z",
     "shell.execute_reply": "2022-05-23T12:13:25.036610Z",
     "shell.execute_reply.started": "2022-05-23T12:13:21.052402Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Debug -- movies sample:\n",
      "+--------+--------------------+--------------------+\n",
      "|movie_id|               title|               genre|\n",
      "+--------+--------------------+--------------------+\n",
      "|       1|    Toy Story (1995)|Animation|Childre...|\n",
      "|       2|      Jumanji (1995)|Adventure|Childre...|\n",
      "|       3|Grumpier Old Men ...|      Comedy|Romance|\n",
      "|       4|Waiting to Exhale...|        Comedy|Drama|\n",
      "|       5|Father of the Bri...|              Comedy|\n",
      "|       6|         Heat (1995)|Action|Crime|Thri...|\n",
      "|       7|      Sabrina (1995)|      Comedy|Romance|\n",
      "|       8| Tom and Huck (1995)|Adventure|Children's|\n",
      "|       9| Sudden Death (1995)|              Action|\n",
      "|      10|    GoldenEye (1995)|Action|Adventure|...|\n",
      "+--------+--------------------+--------------------+\n",
      "only showing top 10 rows\n",
      "\n",
      "Debug -- ratings sample:\n",
      "+-------+--------+------+---------+\n",
      "|user_id|movie_id|rating|timestamp|\n",
      "+-------+--------+------+---------+\n",
      "|      1|    1193|   5.0|978300760|\n",
      "|      1|     661|   3.0|978302109|\n",
      "|      1|     914|   3.0|978301968|\n",
      "|      1|    3408|   4.0|978300275|\n",
      "|      1|    2355|   5.0|978824291|\n",
      "|      1|    1197|   3.0|978302268|\n",
      "|      1|    1287|   5.0|978302039|\n",
      "|      1|    2804|   5.0|978300719|\n",
      "|      1|     594|   4.0|978302268|\n",
      "|      1|     919|   4.0|978301368|\n",
      "+-------+--------+------+---------+\n",
      "only showing top 10 rows\n",
      "\n",
      "Debug -- users sample:\n",
      "+-------+------+---+----------+-----+\n",
      "|user_id|gender|age|occupation|  zip|\n",
      "+-------+------+---+----------+-----+\n",
      "|      1|     F|  1|        10|48067|\n",
      "|      2|     M| 56|        16|70072|\n",
      "|      3|     M| 25|        15|55117|\n",
      "|      4|     M| 45|         7|02460|\n",
      "|      5|     M| 25|        20|55455|\n",
      "|      6|     F| 50|         9|55117|\n",
      "|      7|     M| 35|         1|06810|\n",
      "|      8|     M| 25|        12|11413|\n",
      "|      9|     M| 25|        17|61614|\n",
      "|     10|     F| 35|         1|95370|\n",
      "+-------+------+---+----------+-----+\n",
      "only showing top 10 rows\n",
      "\n",
      "Debug -- dataset sample:\n",
      "+-------+------+---+----------+-----+--------+--------------------+--------------------+------+---------+\n",
      "|user_id|gender|age|occupation|  zip|movie_id|               title|               genre|rating|timestamp|\n",
      "+-------+------+---+----------+-----+--------+--------------------+--------------------+------+---------+\n",
      "|      1|     F|  1|        10|48067|    1193|One Flew Over the...|               Drama|   5.0|978300760|\n",
      "|      1|     F|  1|        10|48067|     661|James and the Gia...|Animation|Childre...|   3.0|978302109|\n",
      "|      1|     F|  1|        10|48067|     914| My Fair Lady (1964)|     Musical|Romance|   3.0|978301968|\n",
      "|      1|     F|  1|        10|48067|    3408|Erin Brockovich (...|               Drama|   4.0|978300275|\n",
      "|      1|     F|  1|        10|48067|    2355|Bug's Life, A (1998)|Animation|Childre...|   5.0|978824291|\n",
      "|      1|     F|  1|        10|48067|    1197|Princess Bride, T...|Action|Adventure|...|   3.0|978302268|\n",
      "|      1|     F|  1|        10|48067|    1287|      Ben-Hur (1959)|Action|Adventure|...|   5.0|978302039|\n",
      "|      1|     F|  1|        10|48067|    2804|Christmas Story, ...|        Comedy|Drama|   5.0|978300719|\n",
      "|      1|     F|  1|        10|48067|     594|Snow White and th...|Animation|Childre...|   4.0|978302268|\n",
      "|      1|     F|  1|        10|48067|     919|Wizard of Oz, The...|Adventure|Childre...|   4.0|978301368|\n",
      "+-------+------+---+----------+-----+--------+--------------------+--------------------+------+---------+\n",
      "only showing top 10 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "users, movies, ratings = read_dataset(**params)\n",
    "merged_dataset = merge_dataset(users, movies, ratings)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c9c2bb3-71e2-4388-84fa-9c556e51bbdd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T04:49:23.300315Z",
     "iopub.status.busy": "2022-05-23T04:49:23.299837Z",
     "iopub.status.idle": "2022-05-23T04:49:23.304431Z",
     "shell.execute_reply": "2022-05-23T04:49:23.303714Z",
     "shell.execute_reply.started": "2022-05-23T04:49:23.300281Z"
    }
   },
   "source": [
    "### 3.数据分析\n",
    "针对MovieLens 1M的数据，这个数据集中一共包含了6040个用户对3883部电影进行评价。我们在这里简要的做下数据分析：\n",
    "* 首先，使用饼图分析一下电影的评分的分布情况，即从1～5评分的百分比；\n",
    "* 其次，使用增强箱图分析一下不同类型电影的流行度分布，横轴是电影的类型，纵轴是评价电影的用户数量；\n",
    "* 最后，使用柱状图分析一下用户观看电影的数量分布。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01a7ea22-2500-4647-b00e-2711518f5cf1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T08:31:00.780401Z",
     "iopub.status.busy": "2022-05-23T08:31:00.779872Z",
     "iopub.status.idle": "2022-05-23T08:31:00.782986Z",
     "shell.execute_reply": "2022-05-23T08:31:00.782530Z",
     "shell.execute_reply.started": "2022-05-23T08:31:00.780372Z"
    }
   },
   "source": [
    "#### 3.1 电影评分分布饼图绘制"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f245692c-7f38-4fe2-a8d6-010a3800f463",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:25.038954Z",
     "iopub.status.busy": "2022-05-23T12:13:25.038694Z",
     "iopub.status.idle": "2022-05-23T12:13:27.395525Z",
     "shell.execute_reply": "2022-05-23T12:13:27.394754Z",
     "shell.execute_reply.started": "2022-05-23T12:13:25.038924Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 6:==============>                                            (1 + 3) / 4]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------+------+\n",
      "|rating| count|\n",
      "+------+------+\n",
      "|   5.0|226310|\n",
      "|   4.0|348971|\n",
      "|   3.0|261197|\n",
      "|   2.0|107557|\n",
      "|   1.0| 56174|\n",
      "+------+------+\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# 统计每个打分的人数\n",
    "star = ratings.groupby('rating').count().sort(F.desc(\"rating\"))\n",
    "star.show(20,True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1103e5f2-1e36-4fdc-8ed8-184b8a991d94",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:27.397118Z",
     "iopub.status.busy": "2022-05-23T12:13:27.396643Z",
     "iopub.status.idle": "2022-05-23T12:13:29.742456Z",
     "shell.execute_reply": "2022-05-23T12:13:29.741936Z",
     "shell.execute_reply.started": "2022-05-23T12:13:27.397092Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   rating   count\n",
      "0     5.0  226310\n",
      "1     4.0  348971\n",
      "2     3.0  261197\n",
      "3     2.0  107557\n",
      "4     1.0   56174\n"
     ]
    }
   ],
   "source": [
    "# 转换成Pandas格式\n",
    "star_pd = star.toPandas()\n",
    "print(star_pd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4e3c2d6b-3050-4190-984a-2ee924a44b46",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:29.743510Z",
     "iopub.status.busy": "2022-05-23T12:13:29.743282Z",
     "iopub.status.idle": "2022-05-23T12:13:30.661020Z",
     "shell.execute_reply": "2022-05-23T12:13:30.660271Z",
     "shell.execute_reply.started": "2022-05-23T12:13:29.743491Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['5.0 star(s)', '4.0 star(s)', '3.0 star(s)', '2.0 star(s)', '1.0 star(s)']\n",
      "[226310.0, 348971.0, 261197.0, 107557.0, 56174.0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 将每个评分人数画成饼图\n",
    "star_score = []\n",
    "star_count = []\n",
    "def count_star(row):\n",
    "    star_score.append(str(row['rating'])+ \" star(s)\")\n",
    "    star_count.append(row['count'])\n",
    "star_pd.apply(count_star, axis=1)\n",
    "print(star_score)\n",
    "print(star_count)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.figure(figsize=(12, 6), dpi=100)\n",
    "plt.pie(star_count,labels=star_score,autopct='%1.1f%%', shadow=False,startangle=150)\n",
    "plt.savefig('user_rating_pie.png', dpi=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02e4a8cd-7eea-4a52-a9d7-5292382adcc9",
   "metadata": {},
   "source": [
    "#### 3.2 电影流行度增强箱图绘制"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e1dcad41-77d2-4326-9a9a-a0b56091e345",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:30.662644Z",
     "iopub.status.busy": "2022-05-23T12:13:30.662261Z",
     "iopub.status.idle": "2022-05-23T12:13:36.192812Z",
     "shell.execute_reply": "2022-05-23T12:13:36.192037Z",
     "shell.execute_reply.started": "2022-05-23T12:13:30.662605Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 16:==============================================>       (174 + 4) / 200]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+------------+------------+\n",
      "|movie_id|single_genre|rating_users|\n",
      "+--------+------------+------------+\n",
      "|    1035|     Musical|         882|\n",
      "|    2144|      Comedy|         719|\n",
      "|    2005|   Adventure|         716|\n",
      "|    3554|     Romance|         119|\n",
      "|    3702|      Action|        1066|\n",
      "|     562|       Drama|         478|\n",
      "|    1025|   Animation|         293|\n",
      "|    3364|   Film-Noir|         151|\n",
      "|    1222|         War|        1254|\n",
      "|    1135|      Comedy|         407|\n",
      "|    3326|      Comedy|         180|\n",
      "|     748|      Sci-Fi|         417|\n",
      "|    3741|       Drama|         241|\n",
      "|     471|      Comedy|         599|\n",
      "|    3784|      Comedy|         165|\n",
      "|    1649| Documentary|         189|\n",
      "|    2970|   Adventure|          98|\n",
      "|    1468|      Comedy|         144|\n",
      "|    1050| Documentary|         146|\n",
      "|    2377|      Horror|         183|\n",
      "+--------+------------+------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# 统计不同类型电影惯看的用户数量\n",
    "merged_dataset.registerTempTable(\"merged_dataset\")\n",
    "query=\"\"\"\n",
    "select \n",
    "    movie_id, \n",
    "    single_genre, \n",
    "    count(distinct user_id) as rating_users\n",
    "from \n",
    "(\n",
    "    select \n",
    "        user_id,\n",
    "        movie_id, \n",
    "        single_genre\n",
    "    from \n",
    "        merged_dataset\n",
    "    lateral view explode(split(genre,'\\\\\\\\|')) genres AS single_genre \n",
    ")\n",
    "group by \n",
    "    movie_id, single_genre\n",
    "\"\"\"\n",
    "genre_stat = spark.sql(query)\n",
    "genre_stat.show(20, True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "55903344-a2bc-456d-b2eb-b18e153f39dd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:36.194287Z",
     "iopub.status.busy": "2022-05-23T12:13:36.193985Z",
     "iopub.status.idle": "2022-05-23T12:13:39.068579Z",
     "shell.execute_reply": "2022-05-23T12:13:39.067980Z",
     "shell.execute_reply.started": "2022-05-23T12:13:36.194261Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Looking in indexes: https://mirrors.aliyun.com/pypi/simple/\n",
      "Collecting seaborn\n",
      "  Downloading https://mirrors.aliyun.com/pypi/packages/10/5b/0479d7d845b5ba410ca702ffcd7f2cd95a14a4dfff1fde2637802b258b9b/seaborn-0.11.2-py3-none-any.whl (292 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m292.8/292.8 KB\u001b[0m \u001b[31m8.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: pandas>=0.23 in /usr/local/lib/python3.8/dist-packages (from seaborn) (1.4.2)\n",
      "Requirement already satisfied: matplotlib>=2.2 in /home/jovyan/.local/lib/python3.8/site-packages (from seaborn) (3.5.2)\n",
      "Requirement already satisfied: numpy>=1.15 in /usr/local/lib/python3.8/dist-packages (from seaborn) (1.22.3)\n",
      "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.8/dist-packages (from seaborn) (1.8.0)\n",
      "Requirement already satisfied: cycler>=0.10 in /home/jovyan/.local/lib/python3.8/site-packages (from matplotlib>=2.2->seaborn) (0.11.0)\n",
      "Requirement already satisfied: fonttools>=4.22.0 in /home/jovyan/.local/lib/python3.8/site-packages (from matplotlib>=2.2->seaborn) (4.33.3)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.8/dist-packages (from matplotlib>=2.2->seaborn) (2.8.2)\n",
      "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.8/dist-packages (from matplotlib>=2.2->seaborn) (9.1.0)\n",
      "Requirement already satisfied: pyparsing>=2.2.1 in /home/jovyan/.local/lib/python3.8/site-packages (from matplotlib>=2.2->seaborn) (3.0.8)\n",
      "Requirement already satisfied: kiwisolver>=1.0.1 in /home/jovyan/.local/lib/python3.8/site-packages (from matplotlib>=2.2->seaborn) (1.4.2)\n",
      "Requirement already satisfied: packaging>=20.0 in /home/jovyan/.local/lib/python3.8/site-packages (from matplotlib>=2.2->seaborn) (21.3)\n",
      "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.8/dist-packages (from pandas>=0.23->seaborn) (2022.1)\n",
      "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.7->matplotlib>=2.2->seaborn) (1.16.0)\n",
      "Installing collected packages: seaborn\n",
      "Successfully installed seaborn-0.11.2\n"
     ]
    }
   ],
   "source": [
    "!pip install seaborn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "af32d9f9-a06c-4864-8865-f821e292fb4b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:39.069757Z",
     "iopub.status.busy": "2022-05-23T12:13:39.069574Z",
     "iopub.status.idle": "2022-05-23T12:13:45.494501Z",
     "shell.execute_reply": "2022-05-23T12:13:45.493951Z",
     "shell.execute_reply.started": "2022-05-23T12:13:39.069736Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Users')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 将流行度分布使用增强箱图进行表示，横轴是电影的类型，纵轴是评价电影的用户数量\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "genre_stat_pandas = genre_stat.toPandas()\n",
    "plt.figure(figsize=(12, 6), dpi=100)\n",
    "sns.boxenplot(x='single_genre', y='rating_users', data =genre_stat_pandas)\n",
    "plt.yscale('log')\n",
    "plt.yticks(fontsize=10)\n",
    "plt.xticks(rotation=55, fontsize=10)\n",
    "plt.xlabel('Genre', fontsize=12)\n",
    "plt.ylabel('Users',fontsize=12)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e71d6d04-6c4b-47f8-b008-d4e9a6121027",
   "metadata": {},
   "source": [
    "#### 3.3 用户观看电影的数量柱状图绘制"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "57ef4e6a-c928-493c-9fce-7f15a6afd033",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:45.495763Z",
     "iopub.status.busy": "2022-05-23T12:13:45.495372Z",
     "iopub.status.idle": "2022-05-23T12:13:48.292408Z",
     "shell.execute_reply": "2022-05-23T12:13:48.291579Z",
     "shell.execute_reply.started": "2022-05-23T12:13:45.495738Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 24:=========================================>            (155 + 4) / 200]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+-----------+\n",
      "|user_id|movie_count|\n",
      "+-------+-----------+\n",
      "|    474|        318|\n",
      "|    964|         78|\n",
      "|   1697|        354|\n",
      "|   1950|        137|\n",
      "|   2214|         81|\n",
      "|   2250|         67|\n",
      "|   2453|        629|\n",
      "|   2529|        812|\n",
      "|   3091|         64|\n",
      "|   5556|        278|\n",
      "|     26|        400|\n",
      "|     29|        108|\n",
      "|   1677|         43|\n",
      "|   5385|         46|\n",
      "|   1806|        214|\n",
      "|   2927|         62|\n",
      "|   4823|        470|\n",
      "|   4590|         50|\n",
      "|   3506|         68|\n",
      "|   2040|         46|\n",
      "+-------+-----------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# 统计每位用户给多少电影打分\n",
    "watch = ratings.groupby('user_id').agg(F.countDistinct('movie_id').alias('movie_count'))\n",
    "watch.show(20,True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "63097968-1729-4256-9079-2a116dad6e31",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:48.293739Z",
     "iopub.status.busy": "2022-05-23T12:13:48.293289Z",
     "iopub.status.idle": "2022-05-23T12:13:51.240208Z",
     "shell.execute_reply": "2022-05-23T12:13:51.239625Z",
     "shell.execute_reply.started": "2022-05-23T12:13:48.293697Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 27:============================================>         (164 + 4) / 200]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+-----------+---------+\n",
      "|user_id|movie_count|count_bin|\n",
      "+-------+-----------+---------+\n",
      "|    474|        318|        3|\n",
      "|    964|         78|        0|\n",
      "|   1697|        354|        3|\n",
      "|   1950|        137|        1|\n",
      "|   2214|         81|        0|\n",
      "|   2250|         67|        0|\n",
      "|   2453|        629|        6|\n",
      "|   2529|        812|        8|\n",
      "|   3091|         64|        0|\n",
      "|   5556|        278|        2|\n",
      "|     26|        400|        4|\n",
      "|     29|        108|        1|\n",
      "|   1677|         43|        0|\n",
      "|   5385|         46|        0|\n",
      "|   1806|        214|        2|\n",
      "|   2927|         62|        0|\n",
      "|   4823|        470|        4|\n",
      "|   4590|         50|        0|\n",
      "|   3506|         68|        0|\n",
      "|   2040|         46|        0|\n",
      "+-------+-----------+---------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# 新加的count_bin是观看电影数量所在的区间\n",
    "watch = watch.withColumn(\"count_bin\",(watch['movie_count']/100).cast('int'))\n",
    "watch.show(20,True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d884f6ea-6217-432d-8d3c-92a09fb9f8ff",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:51.241195Z",
     "iopub.status.busy": "2022-05-23T12:13:51.241012Z",
     "iopub.status.idle": "2022-05-23T12:13:55.397918Z",
     "shell.execute_reply": "2022-05-23T12:13:55.397088Z",
     "shell.execute_reply.started": "2022-05-23T12:13:51.241175Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 31:==============================================>       (174 + 4) / 200]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------+----------+\n",
      "|count_bin|user_count|\n",
      "+---------+----------+\n",
      "|        0|      3095|\n",
      "|        1|      1356|\n",
      "|        2|       624|\n",
      "|        3|       360|\n",
      "|        4|       206|\n",
      "|        5|       140|\n",
      "|        6|        82|\n",
      "|        7|        65|\n",
      "|        8|        49|\n",
      "|        9|        22|\n",
      "|       10|        13|\n",
      "|       11|         6|\n",
      "|       12|        13|\n",
      "|       13|         3|\n",
      "|       15|         3|\n",
      "|       17|         1|\n",
      "|       18|         1|\n",
      "|       23|         1|\n",
      "+---------+----------+\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# 观看电影数量区间对应的人数\n",
    "watch_count = watch.groupby('count_bin').agg(F.countDistinct('user_id')\\\n",
    "                                        .alias('user_count'))\\\n",
    "                                        .sort(F.asc(\"count_bin\"))\n",
    "watch_count.show(20,True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "15a55693-41ee-4678-99a5-29afbeaefde2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:13:55.399488Z",
     "iopub.status.busy": "2022-05-23T12:13:55.399074Z",
     "iopub.status.idle": "2022-05-23T12:14:03.809924Z",
     "shell.execute_reply": "2022-05-23T12:14:03.809431Z",
     "shell.execute_reply.started": "2022-05-23T12:13:55.399457Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 17, 18, 23]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3095, 1356, 624, 360, 206, 140, 82, 65, 49, 22, 13, 6, 13, 3, 3, 1, 1, 1]\n",
      "['0-100', '100-200', '200-300', '300-400', '400-500', '500-600', '600-700', '700-800', '800-900', '900-1000', '1000-1100', '1100-1200', '1200-1300', '1300-1400', '1500-1600', '1700-1800', '1800-1900', '2300-2400']\n"
     ]
    }
   ],
   "source": [
    "# 观影数量区间\n",
    "count_bin = [x['count_bin'] for x in watch_count.select('count_bin').collect()]\n",
    "print(count_bin)\n",
    "# 区间对应人数\n",
    "count_bin_user_num=[x['user_count'] for x in watch_count.select('user_count').collect()]\n",
    "print(count_bin_user_num)\n",
    "# 区间对应的label\n",
    "x_label = [\"%s-%s\"%(100*x, 100*x + 100)for x in count_bin]\n",
    "print(x_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1cd3acc0-e90b-4c8d-aa0f-d700348cf0f4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:14:03.811141Z",
     "iopub.status.busy": "2022-05-23T12:14:03.810774Z",
     "iopub.status.idle": "2022-05-23T12:14:04.077504Z",
     "shell.execute_reply": "2022-05-23T12:14:04.077026Z",
     "shell.execute_reply.started": "2022-05-23T12:14:03.811121Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jovyan/.local/lib/python3.8/site-packages/seaborn/_decorators.py:36: FutureWarning: Pass the following variables as keyword args: x, y. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 柱状图\n",
    "import seaborn as sns\n",
    "sns.set(style=\"whitegrid\")\n",
    "plt.figure(figsize=(12, 6), dpi=100)\n",
    "ax = sns.barplot(count_bin, count_bin_user_num)\n",
    "plt.xlabel('Number of Movies Rated')\n",
    "plt.ylabel('Number of Users')\n",
    "ax.set_xticklabels(x_label, rotation=55)\n",
    "plt.show()\n",
    "plt.savefig('user_watch_count_bin.png', dpi=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8ee04489-c8c3-41ae-bebb-8d38f77f44af",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-23T12:14:04.078364Z",
     "iopub.status.busy": "2022-05-23T12:14:04.078221Z",
     "iopub.status.idle": "2022-05-23T12:14:05.409788Z",
     "shell.execute_reply": "2022-05-23T12:14:05.409276Z",
     "shell.execute_reply.started": "2022-05-23T12:14:04.078348Z"
    }
   },
   "outputs": [],
   "source": [
    "spark.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e581ed17-0d4b-4774-b447-e0da40166aa6",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
